R puede ser utilizado de forma interactiva iniciándolo directamente de cualquier terminal de BASH (en sistemas UNIX-like), o desde el “Simbolo del sistema” o haciendo doble click en el ejecutable típicamente localizado en “C:\Program Files\R\R-version\bin\x64\” (en sistemas Windows). Por ejemplo en cualquier distribución GNU/Linux, bastará con abrir la terminal e ingresar el comando “R”.
Click
en la imagen para agrandar.
Cuando R es iniciado de esa forma, veremos un texto con una pequeña
presentación de R, incluyendo la versión que se está ejecutando y
algunas ayudas básicas. Luego de este texto, vemos una linea vacía
comenzada por el carácter >. Este último carácter se
conoce como prompt y nos indica que R está listo para recibir
órdenes. Así pues, podríamos pedir que nos imprima una bienvenida al
curso utilizando la función print(), haciendo por
ejemplo:
print("Bienvenides al curso!!!")
Click
en la imagen para agrandar.
Aún funcionando desde un CLI, sin una interfaz gráfica, debido a que R está
pensado para funcionar en sistemas de ventanas, es posible realizar
gráficos y estos se mostraran en una nueva ventana exclusivamente creada
para tal fin. Podríamos por ejemplo graficar 3 puntos de diferentes
colores, ubicados en las coordenadas
(x,y)=(1,1 ; 2,1 ; 3,1):
plot(1:3, rep(1,3), pch=16, col=c("blue","red","black"), cex=5)
Click
en la imagen para agrandar.
Como al usar R de esta forma solo podremos ir ejecutando de a una orden a la vez, puede ser conveniente disponer de algún editor de texto plano para poder ir guardando nuestro código a medida que lo vamos escribiendo y ejecutando. Para ello podemos utilizar cualquier editor de texto plano (e.g., en GNU/Linux podemos usar “gedit” o el editor que traiga nuestra distribución; en Windows podemos utilizar “Bloc de Notas”, “Notepad++”, etc). Aprovechando el espacio del escritorio de nuestra PC podríamos entonces hacer una disposición con las ventanas abiertas de nuestra terminal donde ejecutamos R, la ventana gráfica donde se mostrarán nuestros gráficos, el archivo de texto plano con nuestro código y podríamos sumar también una ventana con las carpetas donde estamos guardando el trabajo y desde donde leeremos los datos que cargaremos a R. Algo parecido a lo siguiente:
Click
en la imagen para agrandar.
Finalmente, si deseamos salir de la sesión de R activa, podemos
utilizar la función quit() (o su forma abreviada
q()), a lo que R responderá preguntando si queremos guardar
una imagen del espacio de trabajo, a lo que responderemos que NO
ingresando n. Esto cerrara cualquier ventana gráfica que
hubiera abierta, así como en nuestra terminal veremos que el
prompt vuelve a ser el de nuestro sistema.
Abra R desde una terminal de su sistema operativo e intente replicar las líneas de código mostradas en la parte previa, de paso, sabremos que su sistema tiene correctamente instalado R.
A pesar de lo sencillo que resulta usar R nativamente en cualquier sistema, para ahorrarnos tener que usar múltiples programas en simultáneo, así como para sumar toda una gran colección de funcionalidades y herramientas que nos facilitarán mucho el trabajo, es recomendable utilizar R en conjunto con alguna IDE. En este curso, utilizaremos RStudio.
Click
en la imagen para agrandar.
En la figura precedente podemos identificar rápidamente las principales áreas de trabajo con diferentes funcionalidades que nos ofrece el programa (estos paneles pueden maximizarse, minimizarse o redimensionarse a gusto con el puntero del mouse, así como personalizarse en “Tools > Global Options > Pane Layout”):
Cuando tengamos una rutina (i.e. un script) creada, podremos
ejecutar directamente desde la misma el código sin necesidad de
“copiar y pegar” en la consola de R. Para ello, con el cursor de
texto sobre la linea de código podemos utilizar el botón
Run ubicado en el sector
superior derecho del panel Fuente, o utilizar el atajo de
teclado Ctrl + Enter. Esto mismo podemos hacerlo sobre
varias líneas, seleccionando con el cursor todas aquellas líneas que
querramos ejecutar.
Para prestar atención: un script no es más que una serie ordenada de órdenes que se ejecutan una tras otra. Por defecto, siempre que ejecutemos un script completo, no importa si lo hacemos línea a línea o seleccionado todo el conjunto, la ejecución subyacente es secuencial. Para romper este comportamiento existen estructuras especiales conocidas como “Estructuras de control de flujo”, que estudiaremos más adelante.
Para pensar: en el ejemplo de la figura previa
existen líneas que comienzan con un carácter # (llamado de
muchas formas: numeral, almohadilla, hashtag). Si presta
atención, esas líneas están coloreadas de forma homogénea en el editor
y, además, aparentan tener mensajes que explican el código. ¿Qué imagina
que sucede cuando se ejecutan? ¿Cómo se llama y qué función cumplen esas
líneas? Más adelante veremos otra forma adicional de utilizarlas para
organizar nuestro código en RStudio.
Una de las primeras nociones sobre las buenas prácticas de trabajo es intentar mantener una organización coherente de nuestro código, así como de los archivos de entrada (i.e. los datos) y salida (i.e. resultados, gráficos, etc). Aunque estrictamente no existe una forma única ni correcta de organización y cada persona debe encontrar lo que le resulta más práctico, siempre debemos considerar que existen potenciales receptores de nuestro código que idealmente tendrían que interpretar con el menor esfuerzo posible la organización seguida. Incluso podemos ser nosotros mismos quienes en un futuro revisitemos algo que hicimos hace un tiempo y le estaremos enormemente agradecidos a nuestra versión del pasado por haber mantenido una organización coherente.
Cuando trabajamos con RStudio, esto último puede ser muy sencillo de realizar utilizando los proyectos, que no son otra cosa más que una forma de mantener nuestro trabajo en un contexto dado, con su propio directorio de trabajo, historial, rutinas, entradas, salidas, etc. De esta forma, pensemos por ejemplo en una organización con una estructura hipotética similar a la siguiente:
AnalisisTesis
|
|-- CapII
| |
| |-- datos
| | |-- muestreoEne-Mar.csv
| | |-- muestreoAgo-Oct.csv
| |
| |--resultados
| | |-- diversidad.txt
| | |-- composicion.txt
| | |-- graficos
| | |-- fig_div_estacion.pdf
| | |-- fig_NMDS.pdf
| |
| |-- analisis
| |-- exploratorios.R
| |-- anova.R
| |-- NMDS.R
|-- CapIII
| |
| ...
...
En este caso, podríamos entonces pensar en crear un proyecto para todo el conjunto de “AnalisisTesis” o podemos subdividir y crear un proyecto por cada capítulo que requiera realizar algun tipo de análisis. De nuevo, no hay una manera única, todo dependerá del contexto y lo que resulte -o parezca resultar- óptimo en cada situación.
Existen múltiples formas de crear un nuevo proyecto. Podemos hacer
“File > New Project…”; podemos usar el botón en la esquina superior
izquierda; o utilizar el menú de proyectos
Project: (None),
situado en la esquina superior derecha. A la hora de crear un nuevo
proyecto, podemos elegir partir de un directorio nuevo o de uno
previamente creado. Así mismo, podemos elegir un tipo específico de
proyecto según si estemos haciendo un proyecto general, un proyecto para
un nuevo paquete de R, una aplicación Shiny, etc. Todo esto se realiza mediante
una serie de menús gráficos que se nos irán presentado y que son
sumamente intuitivos de seguir.
Luego de ver la demostración del docente sobre la creación de proyectos en RStudio, abra una sesión propia de RStudio y cree un proyecto para este curso. La organización sugerida es la siguiente:
fundamentosR
|
|-- fundamentosR.Rproj
|-- dia1
| |-- mi_rutinaR.R
|
|--dia2
|--dia3
...
A medida que el curso avance, iremos completando estos directorios con datos, rutinas, etc.
Cree una rutina dentro de dia1, como se muestra en la
estructura precedente, que contenga el código ejecutado en el Ejercicio 1 para el mensaje de bienvenida y el
gráfico. Corra esas líneas y explore las funciones del panel gráfico.
Finalmente, guarde el mismo como un archivo PNG dentro del
directorio dia1.
Cuando trabajamos con R, implícitamente lo estamos haciendo en alguna
ubicación de nuestro sistema de archivos. Los proyectos de RStudio
facilitan esta cuestión haciendo que el directorio de trabajo
sea aquel en el cual creamos el proyecto. Para conocer en donde estamos
trabajando, podemos utilizar la función getwd(). Por
ejemplo, mientras escribo esta guía puedo ver en qué ubicación se
encuentra el proyecto en la cual la estoy realizando (Sí! R es tan
versátil, que hasta podemos crear páginas web y cualquier otro tipo de
documento con su propio formato, imágenes embebidas, vínculos de
internet, etc.):
getwd()
## [1] "/home/usuario/cursoR/clases/1_2_usandoR"
Si por algun motivo deseara cambiar el directorio de trabajo, puedo
hacerlo desde el menú “Session > Set Working Directory
> Choose Directory” o, de forma más sencilla, utilizar la
función setwd():
setwd("/home/usuario/R/mi_proyecto_de_R") # ejecución sin salida en consola
getwd() # muestra el nuevo working directory
## [1] "/home/usuario/R/mi_proyecto_de_R"
setwd("/home/usuario/cursoR/clases/1_2_usandoR/") # regreso al original
getwd() # muestra el nuevo working directory
## [1] "/home/usuario/cursoR/clases/1_2_usandoR"
Una ruta (en inglés path) en R o en cualquier otro sistema informático es la “dirección” de cada archivo que existe en el sistema de archivos. De forma general, existen dos formas de representar a cualquier ruta:
Las rutas absolutas son aquellas en las que
explícitamente se indica todo el trayecto realizado desde la ráiz del
sistema hasta la ubicación en cuestión. En los sistemas GNU/Linux, la
raíz del sistema es / (llamado root);
mientras que en los sistemas Windows será el origen del disco que este
utilizándose, típicamente C:\. Teniendo esto en cuenta, la
ruta anterior al directorio de trabajo es una ruta absoluta, ya que en
la misma se explicita toda la ruta desde la raíz hasta el
archivo.
Las rutas relativas por su parte, nos muestran
la ubicación de un archivo o directorio en sentido relativo al
directorio de trabajo activo. Generalmente, las mismas empiezan con uno
o dos caracteres de punto “.”, teniendo la expresión ./ el
significado literal de “en este directorio”, es decir, en el directorio
actual; mientras que la expresión ../ indica el directorio
superior en la jerarquía del directorio actual. Tener en cuenta que en
sistemas Windows, el caracter que separa directorios es la “barra
inversa”, por lo que en esos sistemas será: .\ y
..\.
Como ejemplo, tomando como referencia la estructura
sugerida para el proyecto de los analisis de la tesis, si el
directorio de trabajo activo fuera analisis dentro de
CapII, la ruta relativa a CapIII seria
../../CapIII
Imagine que dentro del directorio
/home/usuario/Documentos, posee la siguiente estructura de
directorios:
carpeta0/
├── archivo0_a
├── archivo0_b
├── carpeta1
│ ├── archivo1_a
│ ├── archivo1_b
│ └── archivo1_c
└── carpeta2
├── archivo2_a
├── archivo2_b
└── carpeta2a
├── archivo2a_a
└── carpeta2b
└── archivo2b_a
Cuando trabajamos dentro de un proyecto de RStudio, todas las rutas son relativas a la raíz del proyecto. Esto tiene algunas ventajas, como por ejemplo si compartimos nuestro proyecto con colaboradores, estos no necesitarán configurar las rutas para su sistema, ya que las rutas se mantienen relativas al proyecto. Por otro lado, no es necesario que anonimicemos nuestras rutas, ya que si trabajamos exclusivamente dentro de la carpeta raíz del proyecto, no debería aparecer ninguna ruta absoluta. Las razones por las que quisiéramos mantener nuestras otras carpetas internas privadas son muchas, y variarán en cada caso, pero para un ejemplo interesante podemos considerar el siguiente caso:
Click
en la imagen para agrandar.
Por cierto, Alexandra es, ni más ni menos, la creadora del sitio Sci-Hub y esa captura corresponde a una guía básica para voluntarias/os de Anna’s Archive.
Una de las cosas que más intimidan a quienes intentan aprender un lenguaje de programación suele ser intentar recordar el nombre de todas las funciones disponibles y cómo se usa exactamente cada una. Pero lo cierto es que esto rara vez preocupa a quienes llevan un tiempo inmersos en algún lenguaje. Esto es así, ya que como el resto de los lenguajes más populares, R posee un compendio de documentación interna que explica detalladamente cada una de sus funciones. Esta ayuda se encuentra disponible desde la instalación de R, así como de cada uno de los paquetes oficiales, y puede ser consultada incluso fuera de línea (i.e. sin conexión a internet).
Existen múltiples formas de consultar esta documentación. Si nos
encontramos trabajando directamente desde una consola de R, podremos
invocar la ayuda con la función help(funcion), donde
funcion es el nombre de la función o el objeto sobre el que
estamos requiriendo la documentación. Por ejemplo, con la formula
help(help) podemos obtener la ayuda de la función de
ayuda:
Click
en la imagen para agrandar.
Así mismo, disponemos de una versión corta de la función previa, que
es la función ?funcion y en caso de que queramos buscar con
una palabra clave, ya que no recordamos siquiera el nombre de la función
o paquete, podemos utilizar ??palabraclave.
En RStudio, como ya mencionamos antes, disponemos de un área
específica para mostrar la ayuda. Está área se activará automáticamente
al solicitar alguna ayuda, e incluso disponemos de una función de
autocompletado con ayudas en ventanas emergentes. Para
activarla, solo debemos comenzar a escribir el nombre de la función y
apretar la tecla Tab ↹. En la siguiente figura, podemos ver
que sucede al comenzar a escribir “me + Tab ↹”:
Click
en la imagen para agrandar.
En RStudio corra las siguientes líneas de a una y observe que salidas le brinda el programa. Anímese a explorar, no hay nada que pueda romper, haga click aquí y allá, vaya y vuelva. De igual forma, intente utilizar el autocompletado y las ayudas emergentes, fomente su creatividad buscando lo que se le ocurra, o intente averiguar como se usa esa función que hace 2 o 3 semanas que no logra ejecutar sin error. En clase discutiremos que partes componen la ayuda y como interpretarla.
help(help)
?help
??distance
?plot
Además de estas útiles ayudas offline, si contamos con una conexión a internet, por supuesto no dudaremos en hacer uso extensivo de buscadores. Muchas veces, más que saber cómo opera una función en particular, queremos conocer como realizar una acción dada, con el método que sea. Aprender a buscar es en sí mismo un arte. La cantidad de sitios con información sobre R es inabarcable y muchas veces podemos perdernos en el afán de encontrar lo que buscamos, por ello a continuación veremos algunas recomendaciones.
Click
en la imagen para agrandar.
Click
en la imagen para agrandar.
Muy frecuentemente nos encontraremos con errores en la ejecución de alguna línea. Lejos de desanimarnos y/o frustrarnos, debemos pensar que los errores son una oportunidad de aprendizaje. Los errores puede ir desde pequeños errores de tipeo, hasta la falta de memoria de cómputo para la acción requerida, pasando por operaciones imposibles de realizar o falta de argumentos obligatorios en las funciones. En cualquier caso, lo primero que debemos hacer es mantener la calma e intentar interpretar el mensaje de error. Si no logramos solucionarlo por nuestra cuenta, siempre podemos copiar el mensaje y ver que ayuda obtenemos en línea.
data(iris)
iris[iris$Sepal.Length > 3]
## Error in `[.data.frame`(iris, iris$Sepal.Length > 3): undefined columns selected
Click
en la imagen para agrandar.
Sobre los warnings: ocasionalmente R no producirá un mensaje de error, sino una advertencia. En estos casos, también es importante que intentemos entender que está ocasionando este mensaje para saber si es algo crítico o no, sobre todo en cuanto a resultados de análisis se refiere.
Otra fuente de ayuda en los tiempos modernos, es recurrir al chatbot de inteligencia artificial de su preferencia. Una vez más, lo importante es intentar interpretar el código previo a su ejecución. En sentido estricto, podríamos darle nuestros datos a un chatbot y pedirle todos los análisis necesarios y, si supimos desmenuzar e indicar nuestra pregunta correctamente, incluso es posible que la salida sea correcta. Dicho esto, estamos aquí para aprender a hacerlo nosotros mismos, por ende, si bien es una fuente más de ayuda, el objetivo es que aunque el código lo produzca la IA, seamos capaces de entender completamente lo que está sucediendo.
Fuera de estas consideraciones, podemos preguntar directamente como hacer algo, como en el ejemplo que sigue:
Click
en la imagen para agrandar.
O incluso podemos darle algún fragmento de código que falla, y pedirle que intente encontrar el error y explicarnos que es lo que lo esta generando:
Click
en la imagen para agrandar.
Para pensar: más adelante aprenderemos efectivamente a filtrar una tabla basados en una condición. Recuerde la respuesta brindada por la IA en este ejemplo y veremos luego si es una “buena” respuesta.
A medida que usemos R nos surgirá la necesidad de instalar paquetes por fuera de la versión básica, para añadir funcionalidades extras a R. Esto se puede realizar sencillamente desde RStudio, ya sea utilizando la interfaz gráfica o con funciones especificas para la instalación; así como podemos realizar la instalación desde CRAN o desde repositorios externos (e.g. GitHub).
La forma más sencilla de instalar paquetes es usando la función
install.packages(), indicando en el argumento de la función
el nombre del paquete. Si no recordamos exactamente el nombre, podemos
hacer uso de la función de autocompletado (con la tecla
Tab ↹). También podemos utilizar el botón para instalar paquetes, en el
área correspondiente de RStudio. Si usamos esta última forma, se abrirá
una ventana de diálogo, donde podemos indicar el nombre del paquete a
instalar.
Click
en la imagen para agrandar.
Es importante recordar que cuando realicemos la instalación, muchas
veces será necesario instalar otros paquetes que son requeridos para que
funcione correctamente el paquete que queremos usar. Estos paquetes
necesarios se conocen como dependencias y por
defecto R instalará todas las dependencias necesarias. En la siguiente
imagen se muestra la descripción de vegan, un paquete muy popular para
Ecología de Comunidades, dónde podemos ver que depende de los
paquetes permutey lattice, en sus versiones
mínimas 0.9 y 4.1 respectivamente, así como “importa” los
paquetes MASS, cluster y
mgcv.
Click
en la imagen para agrandar.
Dentro de los errores comunes que podemos encontrar tenemos:
No indicamos entre comillas el nombre del paquete. Recordar que
la sintaxis correcta es install.packages("paquete") y no
install.packages(paquete).
Queremos instalar múltiples paquetes sin indicar correctamente la
lista de paquetes a instalar. Recordar que en ese caso sería
install.packages(c("paquete1", "paquete2", "paquete3"))
utilizando la nomenclatura de un vector (más adelante esto
tendrá sentido, no se preocupe si ahora no lo entiende).
Alguna dependencia se encuentra en una versión anterior a la necesaria y no puede actualizarse. Esto normalmente se debe a que otro paquete la tiene fijada en una versión anterior. Se soluciona, generalmente, reiniciando la sesión de R, actualizando independientemente el paquete en cuestión y luego re-intentando la instalación del paquete objetivo. Atención: si un paquete tiende a fijar alguna dependencia en una versión dada, es posible que ese paquete sea viejo y ya no se esté manteniendo; en cuyo caso debemos evaluar si tiene sentido seguir usándolo, principalmente porque al actualizar su dependencia se generará un conflicto y ya no funcionará.
gcc, gfortran,
g++, etc) necesarios para compilar el nuevo paquete.
Resolver estos conflictos puede requerir un poco de tiempo, en tanto
necesitamos identificar cuál es la librería que esta generando el
conflicto, pero suelen resolverse simplemente luego de haber instalado
la dependencia correcta en nuestro Sistema Operativo.Por defecto, cuando abrimos una nueva sesión de R o apenas luego de
que instalamos un nuevo paquete, estos no se encuentran disponibles en
la memoria de trabajo. Para que un paquete particular (y todas las
funciones que este contiene), se carguen en la memoria de trabajo,
debemos llamarlo usando la función library(). Así mismo, si
lo deseamos podemos “descargar” un paquete a fin de liberar memoria,
utilizando la función detach().
# Carga de paquetes
library("remotes")
# Descarga de paquetes
detach("package:remotes", unload = TRUE)
Todo esto en RStudio también puede ser realizado simplemente tildando o destildando el paquete correspondiente en la lista de paquetes.
Instale con el medio que le sea conveniente el paquete
remotes, tal como se muestra en la imagen
previa. Luego use la función library() para cargarlo.
Utilizando las ayudas internas de R responda: ¿para qué sirve este
paquete?
En ocasiones, algunas funciones puede tener igual nombre en
diferentes paquetes. Por defecto, cuando llamamos a una función R
intentará utilizar la función del paquete que más recientemente se haya
cargado. Si deseamos referirnos a una función de un paquete específico
podemos hacerlo utilizando la expresión paquete::funcion().
Por ejemplo:
car::Anova(lm(hp ~ as.factor(cyl), data = mtcars))
## Anova Table (Type II tests)
##
## Response: hp
## Sum Sq Df F value Pr(>F)
## as.factor(cyl) 104031 2 36.177 1.319e-08 ***
## Residuals 41696 29
## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
boxplot(hp ~ cyl, data = mtcars, main = "Relación entre caballos de fuerza (hp) y nº de cilindros (cyl)")
Así como instalamos paquetes desde CRAN, también podemos instalar
paquetes directamente desde los repositorios de código en los que se
encuentran. Existen múltiples paquetes que permiten interactuar con
diferentes repositorios, uno de ellos es el paquete remotes
que instalamos en el ejercicio previo. Si por ejemplo queremos instalar
el paquete multilandr que se encuentra en este
repositorio, podemos hacer:
# URL al repositorio: https://github.com/phuais/multilandr
install_github(repo = "phuais/multilandr")
library(multilandr)
Instale el paquete ggplot2. Una vez instalado, cárguelo
y realice algún gráfico de los ejemplos disponibles en su
vignette. Finalmente, guarde el gráfico en el directorio de
trabajo.